﻿using System;

namespace HalconDotNet
{
	/// <summary>Class grouping system information and manipulation related functionality.</summary>
	// Token: 0x02000069 RID: 105
	public class HSystem
	{
		/// <summary>Delaying the execution of the program.</summary>
		/// <param name="seconds">Number of seconds by which the execution of the program will be delayed. Default: 10</param>
		// Token: 0x060018A4 RID: 6308 RVA: 0x0009DB48 File Offset: 0x0009BD48
		public static void WaitSeconds(double seconds)
		{
			IntPtr proc = HalconAPI.PreCall(315);
			HalconAPI.StoreD(proc, 0, seconds);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Execute a system command.</summary>
		/// <param name="command">Command to be called by the system. Default: "ls"</param>
		// Token: 0x060018A5 RID: 6309 RVA: 0x0009DB74 File Offset: 0x0009BD74
		public static void SystemCall(string command)
		{
			IntPtr proc = HalconAPI.PreCall(316);
			HalconAPI.StoreS(proc, 0, command);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Set HALCON system parameters.</summary>
		/// <param name="systemParameter">Name of the system parameter to be changed. Default: "init_new_image"</param>
		/// <param name="value">New value of the system parameter. Default: "true"</param>
		// Token: 0x060018A6 RID: 6310 RVA: 0x0009DBA0 File Offset: 0x0009BDA0
		public static void SetSystem(HTuple systemParameter, HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(317);
			HalconAPI.Store(proc, 0, systemParameter);
			HalconAPI.Store(proc, 1, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(systemParameter);
			HalconAPI.UnpinTuple(value);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Set HALCON system parameters.</summary>
		/// <param name="systemParameter">Name of the system parameter to be changed. Default: "init_new_image"</param>
		/// <param name="value">New value of the system parameter. Default: "true"</param>
		// Token: 0x060018A7 RID: 6311 RVA: 0x0009DBE0 File Offset: 0x0009BDE0
		public static void SetSystem(string systemParameter, string value)
		{
			IntPtr proc = HalconAPI.PreCall(317);
			HalconAPI.StoreS(proc, 0, systemParameter);
			HalconAPI.StoreS(proc, 1, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Activating and deactivating of HALCON control modes.</summary>
		/// <param name="check">Desired control mode. Default: "default"</param>
		// Token: 0x060018A8 RID: 6312 RVA: 0x0009DC14 File Offset: 0x0009BE14
		public static void SetCheck(HTuple check)
		{
			IntPtr proc = HalconAPI.PreCall(318);
			HalconAPI.Store(proc, 0, check);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(check);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Activating and deactivating of HALCON control modes.</summary>
		/// <param name="check">Desired control mode. Default: "default"</param>
		// Token: 0x060018A9 RID: 6313 RVA: 0x0009DC48 File Offset: 0x0009BE48
		public static void SetCheck(string check)
		{
			IntPtr proc = HalconAPI.PreCall(318);
			HalconAPI.StoreS(proc, 0, check);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Reset the HALCON system for iconic objects.</summary>
		/// <param name="defaultImageWidth">Default image width (in pixels). Default: 128</param>
		/// <param name="defaultImageHeight">Default image height (in pixels). Default: 128</param>
		/// <param name="defaultChannels">Usual number of channels. Default: 0</param>
		// Token: 0x060018AA RID: 6314 RVA: 0x0009DC74 File Offset: 0x0009BE74
		public static void ResetObjDb(int defaultImageWidth, int defaultImageHeight, int defaultChannels)
		{
			IntPtr proc = HalconAPI.PreCall(319);
			HalconAPI.StoreI(proc, 0, defaultImageWidth);
			HalconAPI.StoreI(proc, 1, defaultImageHeight);
			HalconAPI.StoreI(proc, 2, defaultChannels);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Get current value of HALCON system parameters.</summary>
		/// <param name="query">Desired system parameter. Default: "init_new_image"</param>
		/// <returns>Current value of the system parameter.</returns>
		// Token: 0x060018AB RID: 6315 RVA: 0x0009DCB0 File Offset: 0x0009BEB0
		public static HTuple GetSystem(HTuple query)
		{
			IntPtr proc = HalconAPI.PreCall(320);
			HalconAPI.Store(proc, 0, query);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(query);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Get current value of HALCON system parameters.</summary>
		/// <param name="query">Desired system parameter. Default: "init_new_image"</param>
		/// <returns>Current value of the system parameter.</returns>
		// Token: 0x060018AC RID: 6316 RVA: 0x0009DCF8 File Offset: 0x0009BEF8
		public static HTuple GetSystem(string query)
		{
			IntPtr proc = HalconAPI.PreCall(320);
			HalconAPI.StoreS(proc, 0, query);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>State of the HALCON control modes.</summary>
		/// <returns>Tuplet of the currently activated control modes.</returns>
		// Token: 0x060018AD RID: 6317 RVA: 0x0009DD38 File Offset: 0x0009BF38
		public static HTuple GetCheck()
		{
			IntPtr proc = HalconAPI.PreCall(321);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Inquiry after the error text of a HALCON error number.</summary>
		/// <param name="errorCode">HALCON error code.</param>
		/// <returns>Corresponding error message.</returns>
		// Token: 0x060018AE RID: 6318 RVA: 0x0009DD70 File Offset: 0x0009BF70
		public static string GetErrorText(int errorCode)
		{
			IntPtr proc = HalconAPI.PreCall(322);
			HalconAPI.StoreI(proc, 0, errorCode);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Passed Time.</summary>
		/// <returns>Processtime since the program start.</returns>
		// Token: 0x060018AF RID: 6319 RVA: 0x0009DDB0 File Offset: 0x0009BFB0
		public static double CountSeconds()
		{
			IntPtr proc = HalconAPI.PreCall(323);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Number of entries in the HALCON database.</summary>
		/// <param name="relationName">Relation of interest of the HALCON database. Default: "object"</param>
		/// <returns>Number of tuples in the relation.</returns>
		// Token: 0x060018B0 RID: 6320 RVA: 0x0009DDE8 File Offset: 0x0009BFE8
		public static int CountRelation(string relationName)
		{
			IntPtr proc = HalconAPI.PreCall(324);
			HalconAPI.StoreS(proc, 0, relationName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Returns the extended error information for the calling thread's last HALCON error.</summary>
		/// <param name="errorCode">Extended error code.</param>
		/// <param name="errorMessage">Extended error message.</param>
		/// <returns>Operator that set the error code.</returns>
		// Token: 0x060018B1 RID: 6321 RVA: 0x0009DE28 File Offset: 0x0009C028
		public static string GetExtendedErrorInfo(out int errorCode, out string errorMessage)
		{
			IntPtr proc = HalconAPI.PreCall(344);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out errorCode);
			num = HalconAPI.LoadS(proc, 2, num, out errorMessage);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query of used modules and the module key.</summary>
		/// <param name="moduleKey">Key for license manager.</param>
		/// <returns>Names of used modules.</returns>
		// Token: 0x060018B2 RID: 6322 RVA: 0x0009DE84 File Offset: 0x0009C084
		public static HTuple GetModules(out int moduleKey)
		{
			IntPtr proc = HalconAPI.PreCall(345);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out moduleKey);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Inquiring for possible settings of the HALCON debugging tool.</summary>
		/// <param name="values">Corresponding state of the control modes.</param>
		/// <returns>Available control modes (see also set_spy).</returns>
		// Token: 0x060018B3 RID: 6323 RVA: 0x0009DED0 File Offset: 0x0009C0D0
		public static HTuple QuerySpy(out HTuple values)
		{
			IntPtr proc = HalconAPI.PreCall(371);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out values);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Control of the HALCON Debugging Tools.</summary>
		/// <param name="classVal">Control mode Default: "mode"</param>
		/// <param name="value">State of the control mode to be set. Default: "on"</param>
		// Token: 0x060018B4 RID: 6324 RVA: 0x0009DF1C File Offset: 0x0009C11C
		public static void SetSpy(string classVal, HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(372);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.Store(proc, 1, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(value);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Control of the HALCON Debugging Tools.</summary>
		/// <param name="classVal">Control mode Default: "mode"</param>
		/// <param name="value">State of the control mode to be set. Default: "on"</param>
		// Token: 0x060018B5 RID: 6325 RVA: 0x0009DF58 File Offset: 0x0009C158
		public static void SetSpy(string classVal, string value)
		{
			IntPtr proc = HalconAPI.PreCall(372);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.StoreS(proc, 1, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Current configuration of the HALCON debugging-tool.</summary>
		/// <param name="classVal">Control mode Default: "mode"</param>
		/// <returns>State of the control mode.</returns>
		// Token: 0x060018B6 RID: 6326 RVA: 0x0009DF8C File Offset: 0x0009C18C
		public static HTuple GetSpy(string classVal)
		{
			IntPtr proc = HalconAPI.PreCall(373);
			HalconAPI.StoreS(proc, 0, classVal);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Set AOP information for operators.</summary>
		/// <param name="operatorName">Operator to set information to Default: ""</param>
		/// <param name="indexName">Further specific index Default: ""</param>
		/// <param name="indexValue">Further specific address Default: ""</param>
		/// <param name="infoName">Scope of information Default: "max_threads"</param>
		/// <param name="infoValue">AOP information value</param>
		// Token: 0x060018B7 RID: 6327 RVA: 0x0009DFCC File Offset: 0x0009C1CC
		public static void SetAopInfo(HTuple operatorName, HTuple indexName, HTuple indexValue, string infoName, HTuple infoValue)
		{
			IntPtr proc = HalconAPI.PreCall(566);
			HalconAPI.Store(proc, 0, operatorName);
			HalconAPI.Store(proc, 1, indexName);
			HalconAPI.Store(proc, 2, indexValue);
			HalconAPI.StoreS(proc, 3, infoName);
			HalconAPI.Store(proc, 4, infoValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(operatorName);
			HalconAPI.UnpinTuple(indexName);
			HalconAPI.UnpinTuple(indexValue);
			HalconAPI.UnpinTuple(infoValue);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Set AOP information for operators.</summary>
		/// <param name="operatorName">Operator to set information to Default: ""</param>
		/// <param name="indexName">Further specific index Default: ""</param>
		/// <param name="indexValue">Further specific address Default: ""</param>
		/// <param name="infoName">Scope of information Default: "max_threads"</param>
		/// <param name="infoValue">AOP information value</param>
		// Token: 0x060018B8 RID: 6328 RVA: 0x0009E034 File Offset: 0x0009C234
		public static void SetAopInfo(string operatorName, string indexName, string indexValue, string infoName, int infoValue)
		{
			IntPtr proc = HalconAPI.PreCall(566);
			HalconAPI.StoreS(proc, 0, operatorName);
			HalconAPI.StoreS(proc, 1, indexName);
			HalconAPI.StoreS(proc, 2, indexValue);
			HalconAPI.StoreS(proc, 3, infoName);
			HalconAPI.StoreI(proc, 4, infoValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Return AOP information for operators. </summary>
		/// <param name="operatorName">Operator to get information for</param>
		/// <param name="indexName">Further index stages Default: ["iconic_type","parameter:0"]</param>
		/// <param name="indexValue">Further index values Default: ["byte",""]</param>
		/// <param name="infoName">Scope of information Default: "max_threads"</param>
		/// <returns>Value of information</returns>
		// Token: 0x060018B9 RID: 6329 RVA: 0x0009E084 File Offset: 0x0009C284
		public static HTuple GetAopInfo(HTuple operatorName, HTuple indexName, HTuple indexValue, string infoName)
		{
			IntPtr proc = HalconAPI.PreCall(567);
			HalconAPI.Store(proc, 0, operatorName);
			HalconAPI.Store(proc, 1, indexName);
			HalconAPI.Store(proc, 2, indexValue);
			HalconAPI.StoreS(proc, 3, infoName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(operatorName);
			HalconAPI.UnpinTuple(indexName);
			HalconAPI.UnpinTuple(indexValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Return AOP information for operators. </summary>
		/// <param name="operatorName">Operator to get information for</param>
		/// <param name="indexName">Further index stages Default: ["iconic_type","parameter:0"]</param>
		/// <param name="indexValue">Further index values Default: ["byte",""]</param>
		/// <param name="infoName">Scope of information Default: "max_threads"</param>
		/// <returns>Value of information</returns>
		// Token: 0x060018BA RID: 6330 RVA: 0x0009E0F0 File Offset: 0x0009C2F0
		public static string GetAopInfo(string operatorName, HTuple indexName, HTuple indexValue, string infoName)
		{
			IntPtr proc = HalconAPI.PreCall(567);
			HalconAPI.StoreS(proc, 0, operatorName);
			HalconAPI.Store(proc, 1, indexName);
			HalconAPI.Store(proc, 2, indexValue);
			HalconAPI.StoreS(proc, 3, infoName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(indexName);
			HalconAPI.UnpinTuple(indexValue);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query indexing structure of AOP information for operators. </summary>
		/// <param name="operatorName">Operator to get information for Default: ""</param>
		/// <param name="indexName">Further specific index Default: ""</param>
		/// <param name="indexValue">Further specific address Default: ""</param>
		/// <param name="value">Values of next index stage</param>
		/// <returns>Name of next index stage</returns>
		// Token: 0x060018BB RID: 6331 RVA: 0x0009E154 File Offset: 0x0009C354
		public static HTuple QueryAopInfo(HTuple operatorName, HTuple indexName, HTuple indexValue, out HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(568);
			HalconAPI.Store(proc, 0, operatorName);
			HalconAPI.Store(proc, 1, indexName);
			HalconAPI.Store(proc, 2, indexValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(operatorName);
			HalconAPI.UnpinTuple(indexName);
			HalconAPI.UnpinTuple(indexValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out value);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Query indexing structure of AOP information for operators. </summary>
		/// <param name="operatorName">Operator to get information for Default: ""</param>
		/// <param name="indexName">Further specific index Default: ""</param>
		/// <param name="indexValue">Further specific address Default: ""</param>
		/// <param name="value">Values of next index stage</param>
		/// <returns>Name of next index stage</returns>
		// Token: 0x060018BC RID: 6332 RVA: 0x0009E1C8 File Offset: 0x0009C3C8
		public static HTuple QueryAopInfo(string operatorName, string indexName, string indexValue, out HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(568);
			HalconAPI.StoreS(proc, 0, operatorName);
			HalconAPI.StoreS(proc, 1, indexName);
			HalconAPI.StoreS(proc, 2, indexValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out value);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Check hardware regarding its potential for automatic operator parallelization.</summary>
		/// <param name="operatorName">Operators to check Default: ""</param>
		/// <param name="iconicType">Iconic object types to check Default: ""</param>
		/// <param name="fileName">Knowledge file name Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		// Token: 0x060018BD RID: 6333 RVA: 0x0009E22C File Offset: 0x0009C42C
		public static void OptimizeAop(HTuple operatorName, HTuple iconicType, HTuple fileName, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(569);
			HalconAPI.Store(proc, 0, operatorName);
			HalconAPI.Store(proc, 1, iconicType);
			HalconAPI.Store(proc, 2, fileName);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(operatorName);
			HalconAPI.UnpinTuple(iconicType);
			HalconAPI.UnpinTuple(fileName);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Check hardware regarding its potential for automatic operator parallelization.</summary>
		/// <param name="operatorName">Operators to check Default: ""</param>
		/// <param name="iconicType">Iconic object types to check Default: ""</param>
		/// <param name="fileName">Knowledge file name Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		// Token: 0x060018BE RID: 6334 RVA: 0x0009E298 File Offset: 0x0009C498
		public static void OptimizeAop(string operatorName, string iconicType, string fileName, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(569);
			HalconAPI.StoreS(proc, 0, operatorName);
			HalconAPI.StoreS(proc, 1, iconicType);
			HalconAPI.StoreS(proc, 2, fileName);
			HalconAPI.Store(proc, 3, genParamName);
			HalconAPI.Store(proc, 4, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Write knowledge about hardware dependent behavior of automatic operator parallelization to file.</summary>
		/// <param name="fileName">Name of knowledge file Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		// Token: 0x060018BF RID: 6335 RVA: 0x0009E2F4 File Offset: 0x0009C4F4
		public static void WriteAopKnowledge(string fileName, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(570);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Write knowledge about hardware dependent behavior of automatic operator parallelization to file.</summary>
		/// <param name="fileName">Name of knowledge file Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		// Token: 0x060018C0 RID: 6336 RVA: 0x0009E33C File Offset: 0x0009C53C
		public static void WriteAopKnowledge(string fileName, string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(570);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Load knowledge about hardware dependent behavior of automatic operator parallelization.</summary>
		/// <param name="fileName">Name of knowledge file Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		/// <param name="operatorNames">Updated Operators</param>
		/// <returns>Knowledge attributes</returns>
		// Token: 0x060018C1 RID: 6337 RVA: 0x0009E378 File Offset: 0x0009C578
		public static HTuple ReadAopKnowledge(string fileName, HTuple genParamName, HTuple genParamValue, out HTuple operatorNames)
		{
			IntPtr proc = HalconAPI.PreCall(571);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out operatorNames);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Load knowledge about hardware dependent behavior of automatic operator parallelization.</summary>
		/// <param name="fileName">Name of knowledge file Default: ""</param>
		/// <param name="genParamName">Parameter name Default: "none"</param>
		/// <param name="genParamValue">Parameter value Default: "none"</param>
		/// <param name="operatorNames">Updated Operators</param>
		/// <returns>Knowledge attributes</returns>
		// Token: 0x060018C2 RID: 6338 RVA: 0x0009E3E8 File Offset: 0x0009C5E8
		public static HTuple ReadAopKnowledge(string fileName, string genParamName, string genParamValue, out string operatorNames)
		{
			IntPtr proc = HalconAPI.PreCall(571);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadS(proc, 1, num, out operatorNames);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Specify a window type.</summary>
		/// <param name="windowType">Name of the window type which has to be set. Default: "X-Window"</param>
		// Token: 0x060018C3 RID: 6339 RVA: 0x0009E44C File Offset: 0x0009C64C
		public static void SetWindowType(string windowType)
		{
			IntPtr proc = HalconAPI.PreCall(1173);
			HalconAPI.StoreS(proc, 0, windowType);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Get window characteristics.</summary>
		/// <param name="attributeName">Name of the attribute that should be returned.</param>
		/// <returns>Attribute value.</returns>
		// Token: 0x060018C4 RID: 6340 RVA: 0x0009E478 File Offset: 0x0009C678
		public static HTuple GetWindowAttr(string attributeName)
		{
			IntPtr proc = HalconAPI.PreCall(1175);
			HalconAPI.StoreS(proc, 0, attributeName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Set window characteristics.</summary>
		/// <param name="attributeName">Name of the attribute that should be modified.</param>
		/// <param name="attributeValue">Value of the attribute that should be set.</param>
		// Token: 0x060018C5 RID: 6341 RVA: 0x0009E4B8 File Offset: 0x0009C6B8
		public static void SetWindowAttr(string attributeName, HTuple attributeValue)
		{
			IntPtr proc = HalconAPI.PreCall(1176);
			HalconAPI.StoreS(proc, 0, attributeName);
			HalconAPI.Store(proc, 1, attributeValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attributeValue);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Set window characteristics.</summary>
		/// <param name="attributeName">Name of the attribute that should be modified.</param>
		/// <param name="attributeValue">Value of the attribute that should be set.</param>
		// Token: 0x060018C6 RID: 6342 RVA: 0x0009E4F4 File Offset: 0x0009C6F4
		public static void SetWindowAttr(string attributeName, string attributeValue)
		{
			IntPtr proc = HalconAPI.PreCall(1176);
			HalconAPI.StoreS(proc, 0, attributeName);
			HalconAPI.StoreS(proc, 1, attributeValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}

		/// <summary>Query all available window types.</summary>
		/// <returns>Names of available window types.</returns>
		// Token: 0x060018C7 RID: 6343 RVA: 0x0009E528 File Offset: 0x0009C728
		public static HTuple QueryWindowType()
		{
			IntPtr proc = HalconAPI.PreCall(1177);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Return the HALCON thread ID of the current thread.</summary>
		/// <returns>ID representing the current thread.</returns>
		// Token: 0x060018C8 RID: 6344 RVA: 0x0009E560 File Offset: 0x0009C760
		public static int GetCurrentHthreadId()
		{
			IntPtr proc = HalconAPI.PreCall(2152);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Get current value of system information without requiring a license.</summary>
		/// <param name="query">Desired system parameter. Default: "available_parameters"</param>
		/// <returns>Current value of the system parameter.</returns>
		// Token: 0x060018C9 RID: 6345 RVA: 0x0009E598 File Offset: 0x0009C798
		public static HTuple GetSystemInfo(HTuple query)
		{
			IntPtr proc = HalconAPI.PreCall(2160);
			HalconAPI.Store(proc, 0, query);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(query);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Get current value of system information without requiring a license.</summary>
		/// <param name="query">Desired system parameter. Default: "available_parameters"</param>
		/// <returns>Current value of the system parameter.</returns>
		// Token: 0x060018CA RID: 6346 RVA: 0x0009E5E0 File Offset: 0x0009C7E0
		public static HTuple GetSystemInfo(string query)
		{
			IntPtr proc = HalconAPI.PreCall(2160);
			HalconAPI.StoreS(proc, 0, query);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			return result;
		}

		/// <summary>Attempt to interrupt an operator running in a different thread.</summary>
		/// <param name="HThreadID">Thread that runs the operator to interrupt.</param>
		/// <param name="mode">Interruption mode. Default: "cancel"</param>
		// Token: 0x060018CB RID: 6347 RVA: 0x0009E620 File Offset: 0x0009C820
		public static void InterruptOperator(int HThreadID, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(2161);
			HalconAPI.StoreI(proc, 0, HThreadID);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
		}
	}
}
